home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / waisgate / ztype1.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  8KB  |  329 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4. */
  5.   
  6. #ifndef lint
  7. static char *RCSid = "$Header: /tmp_mnt/net/quake/proj/wais/wais-8-b5/ir/RCS/ztype1.c,v 1.2 92/02/12 14:00:49 jonathan Exp $";
  8. #endif
  9.  
  10. /* Change log:
  11.  * $Log:    ztype1.c,v $
  12.  * Revision 1.2  92/02/12  14:00:49  jonathan
  13.  * Added "$Log" so RCS will put the log message in the header
  14.  * 
  15.    3.26.90    Harry Morris, morris@think.com
  16.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  17. */
  18.  
  19. #define _C_Type_1_Query_
  20.  
  21. #include "ztype1.h"
  22. #include "cutil.h"
  23. #include "panic.h"
  24. #include <string.h>
  25.  
  26. #ifndef ANSI_LIKE
  27. #include "ustubs.h"
  28. #endif
  29.  
  30. /*----------------------------------------------------------------------*/
  31.  
  32. query_term*
  33. makeAttributeTerm(use,
  34.           relation,
  35.           position,
  36.           structure,
  37.           truncation,
  38.           completeness,
  39.           term)
  40. char* use;
  41. char* relation;
  42. char* position;
  43. char* structure;
  44. char* truncation;
  45. char* completeness;
  46. any* term;
  47. {
  48.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  49.  
  50.   qt->TermType = TT_Attribute;
  51.  
  52.   /* copy in the attributes */
  53.   strncpy(qt->Use,use,ATTRIBUTE_SIZE);
  54.   strncpy(qt->Relation,relation,ATTRIBUTE_SIZE);
  55.   strncpy(qt->Position,position,ATTRIBUTE_SIZE);
  56.   strncpy(qt->Structure,structure,ATTRIBUTE_SIZE);
  57.   strncpy(qt->Truncation,truncation,ATTRIBUTE_SIZE);
  58.   strncpy(qt->Completeness,completeness,ATTRIBUTE_SIZE);
  59.  
  60.   qt->Term = duplicateAny(term);
  61.  
  62.   qt->ResultSetID = NULL;
  63.  
  64.   return(qt);
  65. }
  66.  
  67. /*----------------------------------------------------------------------*/
  68.  
  69. query_term*
  70. makeResultSetTerm(resultSet)
  71. any* resultSet;
  72. { 
  73.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  74.  
  75.   qt->TermType = TT_ResultSetID;
  76.  
  77.   qt->ResultSetID = duplicateAny(resultSet);
  78.  
  79.   qt->Term = NULL;
  80.   
  81.   return(qt);
  82. }
  83.  
  84. /*----------------------------------------------------------------------*/
  85.  
  86. query_term* 
  87. makeOperatorTerm(operatorCode)
  88. char* operatorCode;
  89. {
  90.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  91.  
  92.   qt->TermType = TT_Operator;
  93.  
  94.   strncpy(qt->Operator,operatorCode,OPERATOR_SIZE);
  95.  
  96.   qt->Term = NULL;
  97.   qt->ResultSetID = NULL;
  98.  
  99.   return(qt);
  100. }
  101.  
  102. /*----------------------------------------------------------------------*/
  103.  
  104. void 
  105. freeTerm(qt)
  106. query_term* qt;
  107. {
  108.   switch (qt->TermType)
  109.     { case TT_Attribute:
  110.     freeAny(qt->Term);
  111.     break;
  112.       case TT_ResultSetID:
  113.     freeAny(qt->ResultSetID);
  114.     break;
  115.       case TT_Operator:
  116.     /* do nothing */
  117.     break;
  118.       default:
  119.     panic("Implementation error: Unknown term type %ld",
  120.           qt->TermType);
  121.     break;
  122.       }
  123.   s_free(qt);
  124. }
  125.  
  126. /*----------------------------------------------------------------------*/
  127.  
  128. #define ATTRIBUTE_LIST_SIZE    ATTRIBUTE_SIZE * 6
  129. #define AT_DELIMITER    " "
  130.  
  131. char* 
  132. writeQueryTerm(qt,buffer,len)
  133. query_term* qt;
  134. char* buffer;
  135. long* len;
  136. {
  137.   char* buf = buffer;
  138.   char attributes[ATTRIBUTE_LIST_SIZE];
  139.  
  140.   switch (qt->TermType)
  141.     { case TT_Attribute:
  142.     strncpy(attributes,qt->Use,ATTRIBUTE_LIST_SIZE); 
  143.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  144.     s_strncat(attributes,qt->Relation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  145.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  146.     s_strncat(attributes,qt->Position,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  147.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  148.     s_strncat(attributes,qt->Structure,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  149.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  150.     s_strncat(attributes,qt->Truncation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  151.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  152.     s_strncat(attributes,qt->Completeness,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE);
  153.     buf = writeString(attributes,DT_AttributeList,buf,len);
  154.     buf = writeAny(qt->Term,DT_Term,buf,len);
  155.     break;
  156.       case TT_ResultSetID:
  157.     buf = writeAny(qt->ResultSetID,DT_ResultSetID,buf,len);
  158.     break;
  159.       case TT_Operator:
  160.     buf = writeString(qt->Operator,DT_Operator,buf,len);
  161.     break;
  162.       default:
  163.     panic("Implementation error: Unknown term type %ld",
  164.           qt->TermType);
  165.     break;
  166.       }
  167.  
  168.   return(buf);
  169. }
  170.  
  171. /*----------------------------------------------------------------------*/
  172.  
  173. char* 
  174. readQueryTerm(qt,buffer)
  175. query_term** qt;
  176. char* buffer;
  177. {
  178.   char* buf = buffer;
  179.   char  *attributeList = NULL;
  180.   char* operator = NULL;
  181.   any*     term;
  182.   char* use = NULL;
  183.   char* relation = NULL;
  184.   char* position = NULL;
  185.   char* structure = NULL;
  186.   char* truncation = NULL;
  187.   char* completeness;
  188.   any*    resultSetID = NULL;
  189.   data_tag tag;
  190.  
  191.   
  192.   tag = peekTag(buffer);
  193.  
  194.   switch(tag)
  195.     { case DT_AttributeList:
  196.     buf = readString(&attributeList,buf);
  197.     buf = readAny(&term,buf);
  198.     use = strtok(attributeList,AT_DELIMITER);
  199.     relation = strtok(NULL,AT_DELIMITER);
  200.     position = strtok(NULL,AT_DELIMITER);
  201.     structure = strtok(NULL,AT_DELIMITER);
  202.     truncation = strtok(NULL,AT_DELIMITER);
  203.     completeness = strtok(NULL,AT_DELIMITER);
  204.     *qt = makeAttributeTerm(use,relation,position,structure,
  205.                 truncation,completeness,term);
  206.     s_free(attributeList);
  207.     freeAny(term);
  208.     break;
  209.       case DT_ResultSetID:
  210.     buf = readAny(&resultSetID,buf);
  211.     *qt = makeResultSetTerm(resultSetID);    
  212.     freeAny(resultSetID);
  213.     break;
  214.       case DT_Operator:
  215.     buf = readString(&operator,buf);
  216.     *qt = makeOperatorTerm(operator);
  217.     s_free(operator);
  218.     break;
  219.       default:
  220.     REPORT_READ_ERROR(buf);
  221.     break;
  222.       }
  223.   
  224.   return(buf);
  225. }
  226.  
  227. /*----------------------------------------------------------------------*/
  228.  
  229. static unsigned long getQueryTermSize _AP((query_term* qt));
  230.  
  231. static unsigned long
  232. getQueryTermSize(qt)
  233. query_term* qt;
  234. /* figure out how many bytes it will take to write this query */
  235. {
  236.   unsigned long size;
  237.   static char attributes[] = "11 22 33 44 55 66"; /* we just need this to 
  238.                              calculate its written
  239.                              size */
  240.  
  241.   switch (qt->TermType)
  242.     { case TT_Attribute:
  243.     size = writtenStringSize(DT_AttributeList,attributes);
  244.     size += writtenAnySize(DT_Term,qt->Term);
  245.     break;
  246.       case TT_ResultSetID:
  247.     size = writtenAnySize(DT_ResultSetID,qt->ResultSetID);
  248.     break;
  249.       case TT_Operator:
  250.     size = writtenStringSize(DT_Operator,qt->Operator);
  251.     break;
  252.       default:
  253.     panic("Implementation error: Unknown term type %ld",
  254.           qt->TermType);
  255.     break;
  256.       }
  257.  
  258.   return(size);
  259. }
  260.  
  261. /*----------------------------------------------------------------------*/
  262.  
  263. /* A query is simply a null terminated list of query terms. For 
  264.    transmission, a query is written into an any which is sent as
  265.    the user information field. */
  266.  
  267. any*
  268. writeQuery(terms)
  269. query_term** terms;
  270. {
  271.   any* info = NULL;
  272.   char* writePos = NULL;
  273.   char* data = NULL;
  274.   unsigned long size = 0;
  275.   long remaining = 0;
  276.   long i;
  277.   query_term* qt = NULL;
  278.  
  279.   if (terms == NULL)
  280.     return(NULL);
  281.  
  282.   /* calculate the size of write buffer */
  283.   for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i])
  284.     size += getQueryTermSize(qt);
  285.  
  286.   data = (char*)s_malloc((size_t)size);
  287.  
  288.   /* write the terms */
  289.   writePos = data;
  290.   remaining = size;
  291.   for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i])
  292.     writePos = writeQueryTerm(qt,writePos,&remaining);
  293.  
  294.   info = makeAny(size,data);
  295.  
  296.   return(info);
  297. }
  298.  
  299. /*----------------------------------------------------------------------*/
  300.  
  301. query_term**
  302. readQuery(info)
  303. any *info;
  304. {
  305.   char* readPos = info->bytes;
  306.   query_term** terms = NULL;
  307.   query_term* qt = NULL;
  308.   long numTerms = 0;
  309.  
  310.  
  311.   while (readPos < info->bytes + info->size)
  312.     { readPos = readQueryTerm(&qt,readPos);
  313.       if (terms == NULL)
  314.     { terms = (query_term**)s_malloc((size_t)(sizeof(query_term*)*2));
  315.     }
  316.       else
  317.     { terms = 
  318.         (query_term**)s_realloc((char*)terms,
  319.                     (size_t)(sizeof(query_term*)*(numTerms+2)));
  320.       }
  321.       terms[numTerms++] = qt;
  322.       terms[numTerms] = NULL;
  323.     }
  324.  
  325.   return(terms);
  326. }
  327.  
  328. /*----------------------------------------------------------------------*/
  329.